// pages/ledger/ledger.js
const FS = my.getFileSystemManager()
const WXfilePath = my.env.USER_DATA_PATH
const FILETYPE = ".json"
const isOpenConsole = false // true 开启console  false 关闭

var fileList = [] // 根目录
var monthFileList = [] // 本月文件目录
var tableData = []
// 入账
export function insertDataJS(purpose, money, author, authorLabel) {
  insertData(purpose, money, author, authorLabel)
}
// 获取今日账单
export function getTodayDataJS() {
  return Promise.resolve(getFileData())
}
// 获取本月账单
export function getMonthFileListJS() {
  return Promise.resolve(getMonthFileList())
}
// 统计分享本月账单
export function shareMonthFileJS() {
  shareMonthFile()
}
// 删除指定日文件
export function removeFileJS(fileName) {
  let dirData = getTodayFilePath()
  removeFile(dirData.dirName + "/" + fileName)
}
// 页面测试按钮点击事件
// createFileTest() {
// 		this.createFile(this.getTodayFilePath().filePath)
// 	},
// 	insertDataTest() {
// 		this.insertData("抽烟测试写入", 17, "小李同学")
// 	},
// 	removeFileTest() {
// 		this.removeFile(this.getTodayFilePath().filePath)
// 	},
// 	removeDirTest() {
// 		this.removeDir(this.getTodayFilePath().dirName)
// 	},
// 	getFileDataTest() {
// 		this.getFileData()
// 	},

// 文件内数据操作
// 文件内数据操作
// 文件内数据操作
// 文件内数据操作
// 文件内数据操作
// 文件内数据操作

function insertData(purpose, money, author, authorLabel) {
  let todayFilePath = getTodayFilePath()
  // 本次插入数据
  let writeData = {
    id: todayFilePath.timestamp,
    datetime: todayFilePath.datetime,
    time: todayFilePath.time,
    purpose: purpose,
    money: money,
    author: author,
    authorLabel
  }
  if (!purpose) {
    return my.showToast({
      content: "干啥花的钱写上",
    })
  }
  if (money < 0) {
    return my.showToast({
      content: "元子咋还填负了呢",
    })
  }
  if (!author) {
    return my.showToast({
      content: "支出人选了嘛",
    })
  }
  tableData.push(writeData)
  let writeResultData = JSON.stringify(tableData)
  console.log("正在准备插入数据", writeResultData)
  // 判断文件/目录是否存在
  FS.access({
    path: todayFilePath.filePath,
    success(res) {
      console.log("今日文件已创建", res)

      // 文件数据，先删后插
      removeFile(todayFilePath.filePath).then(clearRes => {
        if (!clearRes || typeof JSON.parse(clearRes) != "object") {
          clearRes = JSON.stringify([])
        }
        let writeDataCopy = JSON.parse(clearRes)
        writeDataCopy.push(writeData)
        let writeResultDataCopy = JSON.stringify(writeDataCopy)
        console.log("正在准备追加数据", writeResultDataCopy)
        createFile(todayFilePath.filePath, writeResultDataCopy)
      })
    },
    fail(err) {
      console.log("今日文件未创建", err)
      createFile(todayFilePath.filePath, writeResultData)
    }
  })
}

// 获取指定文件内数据
function getFileData(filePath) {
  return new Promise((resolve, reject) => {
    filePath = !filePath ? getTodayFilePath().filePath : filePath
    my.showLoading({
      content: "正在获取今日账单"
    })
    // 判断文件/目录是否存在
    console.log("查看是否存在文件", filePath)
    FS.access({
      path: filePath,
      success(res) {
        console.log("获取指定文件内数据-今日文件已创建", res)
        let fileData = FS.readFileSync(filePath, 'utf8')
        if (!fileData) {
          reject({
            msg: `文件：${filePath},暂无数据！`,
            data: []
          })
          return my.showToast({
            content: `文件：${filePath},暂无数据！`,
            duration: 5000
          })
        }
        try {
          tableData = JSON.parse(fileData.data)
          console.warn(`查看${filePath}文件内信息`, tableData)
          isOpenConsole ? console.table(tableData) : ""
          resolve({
            msg: `操作成功！`,
            data: tableData
          })
        } catch (e) {
          //TODO handle the exception
          console.error(`${filePath}文件JSON串格式解析失败`, fileData ? fileData : "文件内无数据")
          reject({
            msg: `${filePath}文件JSON串格式解析失败`,
            data: []
          })
        }
      },
      fail(err) {
        if (err === 10022) {
          console.log("获取指定文件内数据-今日文件未创建", err)
          // insertData("机器操作-零元购", 0, "机器小李")
          reject({
            msg: err.errorMessage,
            data: []
          })
        } else {
          console.error("获取指定文件内数据-getFileData-err", err)
          reject({
            msg: `getFileData-err,获取失败`,
            data: []
          })
        }
      },
      complete(com) {
        my.hideLoading()
      }
    })
  })
}








// 文件操作
// 文件操作
// 文件操作
// 文件操作
// 文件操作

// 获取今日文件名称
function getTodayFilePath() {
  let result = ""
  let now = new Date();
  let year = now.getFullYear(); // 年
  let month = (now.getMonth() + 1).toString().padStart(2, '0'); // 月，注意getMonth()是从0开始的
  let date = now.getDate().toString().padStart(2, '0'); // 日
  let hours = now.getHours().toString().padStart(2, '0'); // 时
  let minutes = now.getMinutes().toString().padStart(2, '0'); // 分
  let seconds = now.getSeconds().toString().padStart(2, '0'); // 秒
  let timestamp = now.getTime();

  result = `${WXfilePath}/${year}-${month}/${year}-${month}-${date}${FILETYPE}`
  return {
    filePath: result, // 文件路径
    dirName: `${WXfilePath}/${year}-${month}`, // 文件目录
    dateMonth: `${year}-${month}`, // 当前月份
    datetime: `${year}-${month}-${date} ${hours}:${minutes}:${seconds}`, // 操作日期时间
    timestamp: timestamp, // 操作时间戳
    time: `${hours}:${minutes}:${seconds}`, // 操作时间
  }
}
// 创建文件
function createFile(filePath, jsonData) {
  if (!filePath) {
    return
  }

  FS.access({
    path: filePath,
    success(res) {
      my.showToast({
        content: "文件已存在，无需重复创建",
      })
    },
    fail(err) {
      FS.writeFile({
        filePath: filePath,
        data: jsonData,
        encoding: 'utf8',
        success(res) {
          console.log("文件创建成功", res)
          getFileList()
          my.showToast({
            content: '入账完成了呦，团团爱你呦',
            duration: 5000
          })
        },
        fail(err) {
          console.error("文件创建失败,准备创建本月目录文件夹", err)
          FS.mkdir({
            dirPath: getTodayFilePath().dirName,
            recursive: false,
            success(dirRes) {
              console.log("本月目录创建成功，正在自动重新创建文件", dirRes)
              createFile(filePath, jsonData)
            },
            fail(dirErr) {
              console.error("本月目录创建失败，原因如下1", dirErr)
              console.error("本月目录创建失败，原因如下2", filePath, jsonData)

              my.showToast({
                content: "文件管理服务错误，请联系你老公尽快解决呦",
                duration: 5000
              })
            }
          })
        }
      })
    }
  })
}

// 删除文件
function removeFile(filePath) {
  return new Promise((resolve, reject) => {
    if (!filePath) {
      reject()
    }

    console.warn("正在准备删除文件", filePath)
    // 判断文件/目录是否存在
    FS.access({
      path: filePath.toString(),
      success(res) {
        // 文件存在=读取文件内数据
        let filePathData = FS.readFileSync(filePath, 'utf8')
        // 数据读取后=删除此文件
        FS.unlink({
          filePath,
          success: (res) => {
            console.log("文件删除成功", res)
            getFileList()
            resolve(filePathData)
          },
          fail: err => {
            console.error(`文件${filePath}删除失败`, err)
            my.showToast({
              content: "文件删除失败",
            })
            reject()
          }
        })
      },
      fail(err) {
        // 文件不存在或其他错误
        console.error("文件目录还不存在的呦", err)
        my.showToast({
          content: "文件目录还不存在的呦",
        })
        resolve()
      }
    })
  })
}
// 删除指定月分数据目录
function removeDir(dirPath) {
  if (!dirPath) {
    return
  }
  if (dirPath == WXfilePath) {
    return console.error(WXfilePath, "文件目录不可以删除")
  }
  console.warn("正在准备删除目录", dirPath)
  // 判断文件/目录是否存在
  FS.access({
    path: dirPath.toString(),
    success(res) {
      // 目录存在
      FS.rmdir({
        dirPath: dirPath.toString(),
        recursive: true,
        success: dirRes => {
          console.log(`${dirPath}文件夹删除成功`, dirRes)
        },
        fail: err => {
          console.error(`${dirPath}文件夹删除失败`, err)
        }
      })
    },
    fail(err) {
      // 文件不存在或其他错误
      console.error("文件目录还不存在的呦", err)
      my.showToast({
        content: "文件目录还不存在的呦",
      })
    }
  })
}

// 获取已存在的小程序根目录文件列表
function getFileList() {
  let result = FS.readdirSync(my.env.USER_DATA_PATH)
  console.warn("查看文件列表", result)
  isOpenConsole ? console.table(result) : ""
  fileList = result
  return result
}
// 获取已存在的文件列表
function getMonthFileList() {
  return new Promise((resolve, reject) => {
    let fileMonth = getTodayFilePath().dateMonth
    let dirPath = WXfilePath + "/" + fileMonth

    FS.access({
      path: dirPath.toString(),
      success(res) {
        // 目录存在
        let result = FS.readdirSync(dirPath)
        console.warn(`查看${fileMonth}文件列表`, result)
        isOpenConsole ? console.table(result.files) : ""
        monthFileList = result.files
        resolve(result.files)
      },
      fail(err) {
        // 文件不存在或其他错误
        console.error("getMonthFileList-文件目录还不存在的呦", err)
        my.showToast({
          content: "本月还没有开始记录呦",
        })
        monthFileList = []
        reject(monthFileList)
      }
    })
  })
}

// 统计分享本月账单
function shareMonthFile() {
  let dirData = getTodayFilePath()
  let downFileList = FS.readdirSync(dirData.dirName).files // 本月文件目录下所有文件列表
  let nowMonthTotalDataFileName = dirData.dateMonth + "-合计" + FILETYPE // 月份合计

  // 无文件可提取
  if (downFileList.length <= 0) {
    return my.showToast({
      content: "还没有开始记账哝，保持住好习惯",
      duration: 5000
    })
  }

  my.showModal({
    title: "谨慎操作！",
    content: `请确认是否要对${dirData.dateMonth}月份的账单进行统计！`,
    success: function (res) {
      if (res.confirm) {
        // 统计本月所有数据并生成文件分享
        let nowMonthTotalData = []
        my.showLoading({
          content: "正在统计...",
        })
        try {
          console.log(downFileList)
          downFileList.forEach((fileName, fileIndex) => {
            console.log("正在读取文件...", fileName)
            // 剔除原合计文件
            if (fileName == nowMonthTotalDataFileName) {
              removeFile(dirData.dirName + "/" + nowMonthTotalDataFileName)
            }
            // 读取每日文件数据
            FS.readFile({
              filePath: dirData.dirName + "/" + fileName,
              encoding: 'utf8',
              position: 0,
              success(nowData) {
                let dayName = fileName.split(".")[0]
                nowData = nowData.data ? JSON.parse(nowData.data) : nowData.data
                console.log(nowData)
                nowMonthTotalData.push({
                  [dayName]: nowData
                })
                console.log(`${dayName}文件数据提取完成`, fileIndex,
                  downFileList.length - 1, nowMonthTotalData)
                // 数据提取完成
                if (fileIndex >= downFileList.length - 1) {
                  FS.writeFile({
                    filePath: dirData.dirName + "/" + nowMonthTotalDataFileName,
                    data: JSON.stringify(nowMonthTotalData),
                    encoding: 'utf8',
                    success(writeRes) {
                      console.log(nowMonthTotalDataFileName + "月份统计文件创建成功", writeRes)
                      my.hideLoading()
                      my.showToast({
                        content: "统计文件完成"
                      })
                      getFileList()
                      return
                      my.showModal({
                        title: "团团爱妈妈！",
                        content: "团团：现在就要分享出本月账单嘛",
                        success(shareRes) {
                          if (shareRes.confirm) {
                            getFileList()
                            my.shareFileMessage({
                              filePath: dirData.dirName + "/" + nowMonthTotalDataFileName,
                              fileName: nowMonthTotalDataFileName,
                              success: () => {
                                console.log('分享文件成功');
                                my.showToast({
                                  content: "已完成分享哝！快去跟他吐槽吧。",
                                  duration: 5000
                                })
                              },
                              fail: (shareErr) => {
                                console.log('分享文件失败', shareErr);
                                if (shareErr.errMsg && shareErr.errMsg.indexOf("fail canceled")) {
                                  my.showToast({
                                    content: '咋还取消分享了呢',
                                  })
                                } else {
                                  my.showToast({
                                    content: "CPU要着火啦，快联系小李同学灭火",
                                    duration: 5000
                                  })
                                }
                              }
                            });
                          } else if (shareRes.cancel) {
                            console.log('用户点击取消');
                          }
                        }
                      })
                    },
                    fail(writeErr) {
                      console.error("本月数据统计失败", writeErr)
                      my.hideLoading()
                      my.showToast({
                        content: "本月数据统计失败，快请小李同学！",
                        duration: 5000
                      })
                    }
                  })
                }
              },
              fail(nowErr) {
                console.error(`shareMonthFile-showModal-readFile==${fileName}`, nowErr)
                my.hideLoading()
                my.showToast({
                  content: `${fileName}文件提取失败`,
                })
              }
            })
          })
        } catch (tryCatchErr) {
          //TODO handle the exception
          console.error("查看捕获到的统计错误", tryCatchErr)
        }
      } else if (res.cancel) {
        console.log('用户点击取消');
      }
    }
  })
}